{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一、函数及数据准备"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1、调库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import re\n",
    "import torch\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3、导入数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "CSV_FILE_PATH_TRAIN = 'D:/alltrain/train.csv'   #训练集\n",
    "dfTrain = pd.read_csv(CSV_FILE_PATH_TRAIN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4、清洗数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5000, 8)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfTrain.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#正则匹配，清除非汉字部分\n",
    "def findChinese(sentence):\n",
    "    pattern = re.compile(r'[^\\u4e00-\\u9fa5]')\n",
    "    sentence = re.sub(pattern, '', sentence)\n",
    "    return sentence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "question_beforeClean = np.array(dfTrain.iloc[:, dfTrain.shape[1] - 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "question_afterClean = np.array([findChinese(x) for x in question_beforeClean])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二、建立字典"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1、统计所有不同的字"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getDifferentWord(data):\n",
    "    dic_key = []\n",
    "    for question in data:\n",
    "        for tip in list(question):\n",
    "            if tip not in dic_key:\n",
    "                dic_key.append(tip)\n",
    "    return dic_key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic_key = getDifferentWord(question_afterClean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['病', '情', '描', '述', '人', '是', '典', '型', '的', '三', '高', '想', '吃', '拜', '阿']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic_key[:15]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2、 建立字典"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "bin()  #十进制转二进制函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic = {}\n",
    "value = 1\n",
    "for key in dic_key:\n",
    "    dic[key] = value #在此转换为二进制bin()\n",
    "    value += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  三、建立训练矩阵（将问句转为二进制向量）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1、找到最大维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findDimension(data):\n",
    "    dimension = np.max([len(list(x)) for x in data])\n",
    "    return dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "dimension = findDimension(question_afterClean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1622"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2、生成训练集矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5000, 1622)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.zeros((len(question_afterClean), dimension))    #训练集x\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getValues(sentence, dic):\n",
    "    result = []\n",
    "    for word in list(sentence):\n",
    "        result.append(dic.get(word))\n",
    "    return np.array(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(question_afterClean)):\n",
    "    X[i][:len(list(question_afterClean[i]))] = getValues(question_afterClean[i], dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5000, 6)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.array(dfTrain.iloc[:,1:7])\n",
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 0, 0, 0],\n",
       "       [0, 1, 0, 0, 0, 0],\n",
       "       [0, 1, 0, 0, 0, 0],\n",
       "       ...,\n",
       "       [1, 0, 0, 1, 1, 0],\n",
       "       [0, 0, 0, 0, 0, 1],\n",
       "       [0, 1, 0, 1, 0, 0]], dtype=int64)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3、分割数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 1000, random_state = 666)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "58"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(y_test[:,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 四、训练数据   （使用pytorch）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")          # a CUDA device object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1、转换数据格式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changeType(X_data, y_data):  #将array数据转化为longTensor\n",
    "    return torch.from_numpy(X_data).float(), torch.from_numpy(y_data).float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#X_train = X\n",
    "#y_train = y\n",
    "X_torch_train, y_torch_train = changeType(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_torch_test, y_torch_test = changeType(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2、创建并训练神经网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(torch.nn.Module):     \n",
    "    def __init__(self, n_feature, n_hidden1, n_hidden2,  n_output):\n",
    "        super(Net, self).__init__()     # 继承 __init__ 功能\n",
    "        self.hidden1 = torch.nn.Linear(n_feature, n_hidden1)   # 隐藏层1线性输出\n",
    "        self.hidden2 = torch.nn.Linear(n_hidden1, n_hidden2)\n",
    "        self.out = torch.nn.Linear(n_hidden2, n_output)       # 输出层线性输出\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 正向传播输入值, 神经网络分析出输出值\n",
    "        x = F.relu(self.hidden1(x))      # 激励函数(隐藏层的线性值)\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        x = self.out(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Net"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "net=Net(n_feature = X_train.shape[1], n_hidden1 = 1200, n_hidden2 = 500, n_output = 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Net(\n",
       "  (hidden1): Linear(in_features=1622, out_features=1200, bias=True)\n",
       "  (hidden2): Linear(in_features=1200, out_features=500, bias=True)\n",
       "  (out): Linear(in_features=500, out_features=6, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = net.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.SGD(net.parameters(), lr=0.02)  # 传入 net 的所有参数, 学习率\n",
    "loss_func = torch.nn.BCEWithLogitsLoss()#BCEWithLogitsLoss()针对多标签分类 整合sigmoid，输出的为概率\n",
    "loss_func = loss_func.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_torch_train, y_torch_train = X_torch_train.cuda(), y_torch_train.cuda()   #转为gpu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "acc= [[],[],[],[],[],[]]\n",
    "lossSet= []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\torch\\nn\\functional.py:1625: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
      "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1min 30s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for t in range(3000):\n",
    "    out = net(X_torch_train)     # 喂给 net 训练数据 x, 输出分析值\n",
    "\n",
    "    loss = loss_func(out, y_torch_train)     # 计算两者的误差\n",
    "\n",
    "    optimizer.zero_grad()   # 清空上一步的残余更新参数值\n",
    "\n",
    "    loss.backward()         # 误差反向传播, 计算参数更新值\n",
    "\n",
    "    optimizer.step()        # 将参数更新值施加到 net 的 parameters 上\n",
    "    if t % 2 == 0:\n",
    "        lossSet.append(loss.cpu().data.numpy())\n",
    "        prediction = F.sigmoid(out).cpu() > 0.5\n",
    "        predictRs = prediction.int()\n",
    "        for i in range(len(acc)):\n",
    "            acc[i].append(accuracy_score(y_train[:,i], predictRs[:,i]))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = net.cpu()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "with open('SingleLoss.txt','w') as f:\n",
    "  for i in lossSet:\n",
    "    print(i, file=f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def getS(loss, acc):\n",
    "  with open('SingleLoss.txt','w') as f:\n",
    "    for i in lossSet:\n",
    "      print(i, file=f)\n",
    "  with open('SingleAcc1.txt','w') as f:\n",
    "    for i in acc[0]:\n",
    "      print(i, file=f)\n",
    "  with open('SingleAcc2.txt','w') as f:\n",
    "    for i in acc[1]:\n",
    "      print(i, file=f)\n",
    "  with open('SingleAcc3.txt','w') as f:\n",
    "    for i in acc[2]:\n",
    "      print(i, file=f)\n",
    "  with open('SingleAcc4.txt','w') as f:\n",
    "    for i in acc[3]:\n",
    "      print(i, file=f)\n",
    "  with open('SingleAcc5.txt','w') as f:\n",
    "    for i in acc[4]:\n",
    "      print(i, file=f)\n",
    "  with open('SingleAcc6.txt','w') as f:\n",
    "    for i in acc[5]:\n",
    "      print(i, file=f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "getS(loss,acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sets = []\n",
    "f = open('singleHideLoss.txt','r')               # 返回一个文件对象   \n",
    "line = f.readline().strip()               # 调用文件的 readline()方法\n",
    "sets.append(float(line))\n",
    "while line:   \n",
    "    line = f.readline().strip()\n",
    "    sets.append(float(line))\n",
    "    a = a + 1\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "len(sets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3、预测结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X_test):\n",
    "    test_out = net(X_test)\n",
    "    predictRs = F.sigmoid(test_out).data.numpy() > 0.5\n",
    "    predictRs = predictRs.astype(np.int32)\n",
    "    return predictRs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_torch_train, y_torch_train = X_torch_train.cpu(), y_torch_train.cpu()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = predict(X_torch_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.0051, grad_fn=<CopyBackwards>)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss.cpu()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000, 6)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 四、获取指标   准确率   精准率   召回率   F1-score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1、准确率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.577, 0.562, 1.0, 0.777, 0.848, 0.939]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracySet = []\n",
    "for i in range(6):\n",
    "    #normalize = False  默认为True  如果为False  则显示匹配数量t\n",
    "    accuracySet.append(accuracy_score(y_test[:,i], y_pred[:,i]))\n",
    "accuracySet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2、精确率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.41379310344827586, 0.6597633136094675, 0.0, 0.10752688172043011, 0.16176470588235295, 0.2]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1221: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "precisionSet = []\n",
    "for i in range(6):\n",
    "    precisionSet.append(precision_score(y_test[:,i], y_pred[:,i]))\n",
    "print(precisionSet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def precision(y_test, y_pred):\n",
    "    P = 0\n",
    "    TP = 0\n",
    "    for i in range(len(y_test)):\n",
    "        if (y_pred[i] == 1):\n",
    "            P += 1\n",
    "            if (y_test[i] == 1):\n",
    "                TP += 1\n",
    "    print(P, TP)\n",
    "    return TP / P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "precision(y_train[:,i], y_pred[:,i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3、召回率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1221: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 due to no true samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.43575418994413406,\n",
       " 0.6819571865443425,\n",
       " 0.0,\n",
       " 0.06666666666666667,\n",
       " 0.10377358490566038,\n",
       " 0.017241379310344827]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recallSet = []\n",
    "for i in range(6):\n",
    "    recallSet.append(recall_score(y_test[:,i], y_pred[:,i]))\n",
    "recallSet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def recall(y_test, y_pred):\n",
    "    P = 0\n",
    "    TP = 0\n",
    "    for i in range(len(y_test)):\n",
    "        if (y_test[i] == 1):\n",
    "            P += 1\n",
    "            if (y_pred[i] == 1):\n",
    "                TP += 1\n",
    "    print(P, TP)\n",
    "    return TP / P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "recall(y_train[:,i], y_pred[:,i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4、F1-score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1464: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 due to no true nor predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.4244897959183673,\n",
       " 0.6706766917293233,\n",
       " 0.0,\n",
       " 0.0823045267489712,\n",
       " 0.12643678160919541,\n",
       " 0.031746031746031744]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1Set = []\n",
    "for i in range(6):\n",
    "    f1Set.append(f1_score(y_test[:,i], y_pred[:,i]))\n",
    "f1Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getF1Score(y_test, y_pred):\n",
    "    totalF1 = 0\n",
    "    for i in range(y_test.shape[1]):\n",
    "        totalF1 += f1_score(y_test[:,i], y_pred[:,i])\n",
    "        print(f1_score(y_test[:,i], y_pred[:,i]))\n",
    "    return totalF1 / y_test.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4244897959183673\n",
      "0.6706766917293233\n",
      "0.0\n",
      "0.0823045267489712\n",
      "0.12643678160919541\n",
      "0.031746031746031744\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.2226089712919815"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getF1Score(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "axis = [ x * 2 for x in range(0,1500)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "axis[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(axis,lossSet)\n",
    "plt.text(2000, 0.4, 'loss' , fontdict={'size': 20, 'color': 'red'})\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.ylim(0,1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZxcVZn/8c/Te5JO0tmXzkoShIAkITGAyK4s0RHBDXRQcZQfKg46owOM+nObHyM6gguMEUcGUGRRURmMRGBYNQgJJJCQhDQJSToJSSfp7N3ppZ7fH/dWV6W7qrf07aru+32/Xv2qu5y69dyq5D73nHPvuebuiIhIfBXkOgAREcktJQIRkZhTIhARiTklAhGRmFMiEBGJuaJcB9BVI0eO9ClTpuQ6DBGRPmXZsmU73X1UpnV9LhFMmTKFpUuX5joMEZE+xcw2ZlunpiERkZhTIhARiTklAhGRmFMiEBGJOSUCEZGYiywRmNkdZrbDzFZmWW9m9iMzqzKzl83s5KhiERGR7KKsEdwJXNjO+ouAGeHfVcBPIoxFRESyiOw+And/2symtFPkYuBuD8bBfs7MKsxsnLtviyomEQB3J+GQcKc54eyta6SxOYE7eLg8EZZJlnWcRAKaE87OA4epOXCYg4eb2vmMdj6/E/F1V/uf2/52jy7maD63I+19Vx1tt73VHb83uu+yvTfPmzKcM4/NeE/YUcnlDWWVwOa0+epwWZtEYGZXEdQamDRpUq8EJ7lX39iMO9TsP8yBw000NCd4c289r27bx55DDdQeaqSpOUFjc4K6xmbe2HmIvXWNlBQVUFpUwPBBJWzcdYjG5kTLgT3hflQHHpHeYJZ5+dVnTet3iSDTrmb8L+rutwO3A8ybN0//jfuIxuYERQXGzgMNrK85EJ55O02JBNW1dew60MDhpmZ2HjjM7oMNlBUX0pxwDjcl2L6vnjf31tOUyPxzDy4rYsSgEooLCyguLKCkqIC5k4cxoryEhqYE9Y0JqmsPccEJYxk5uIQCMwrNKDAwMwoLUtNDBhRTWlRAQct6KDDDwvkCMwxa5keUlzKyvIShA4rb3X/L+E+8ZWX77+3+W7F23tzxe9v73Pbf3d57OxLV5+bqu+po2/kml4mgGpiYNj8B2JqjWKSL3B0zw91ZtXUfL22qxcwYO6SMN3Yd5I5nN7B1bz2DSgo52NCccRsDSwoZUFxIxcBizIyBJYngoF5YwLzJwxg7dACDy4oYVV7KkAHFlBQZxYUFzJpYwZCy9g/CItJ5uUwEDwHXmNl9wCnAXvUP5J8te+rYuPMgG3cfIuHOX1/fxZbaOlZv20dZcSHuzr76tm3lY4aUcv7MMYwdWsaIQaXMnlSRdgZvlJcVMXpwWQ72SERaiywRmNm9wNnASDOrBr4OFAO4+0JgEbAAqAIOAVdGFYt0zaZdh7hp8RqeWLODQxnO5oeUFXHpyZXsrWukrLiQmeOGcPr0kbhDUyLBgOJCpowcRHGhblMR6QuivGro8g7WO/C5qD5fOufg4Sb+88kq3jurkmPHlPONh1Zx15JgkML3zhrPiZVDOH7cEI4ZVU6hGQNLC9UsI9LP9LlhqKVnNDYnWL55D1+8fznVtXX8/qWtfP9Ds7hryUbeefxorr/oOKaPHpzrMEWkFygRxMwdz27gx/+7jtpDjQCMHlzKqccM57n1u3nwxWoAbnr/SYwoL81lmCLSi5QI+rHDTc186q6lPLNuJw/8n9N4y5jBfOvhVwFY8NaxTB89mEvnVNLQnOD8W57mhTdqMYNhA0tyHLmI9CYlgn7qdy9V88X7V7TMf/H+5Xz5grcAcO+nT+W0aSNa1iXvkN2w8yCDS4soKOg71z+LyNHTZR39xGOvbmf2t/7Me378DHvrGvnhY+sA+OkVc/n0GVPZsqeOx9fsYEBxIadMHX7EeweWFFISXuEzuEznBiJxo0TQD2zdU8e1973EnkONrNyyj58/u4Hq2jo+e/Y0LjhhLBecMBaAFzfWMqCksM0Zv5kxdGBwJVBJkf5JiMSN/tf3Ue7ODx57jec37Oaev23kcFOCZ/7lHN42ZRi/+ttGmhLOhGEDARgZdvzWHmqgMEuzz+DSoCbQl26LF5GeoXaAPuq9t/6FV7bs5adPrefc40YzcfhAJg4fyAnjh/LCG7UAVA4bAMDA0kIADjU0U5FlfJyy4qCM0oBI/KhG0EfUNzazY189ACu37OWVLXsBqGts5pUte5k4PDj7H1+RGrZhWNjcM6gkle8LCzMf6geUBIlAmUAkfpQI+oD6xmYW/OgZ5t/4OH+p2sk3/2cVwweV8LOPzQNg0+5DTAzP/ocPSl3/Pzi8A3hAeLYPUFyQ+ScvKw6WKw+IxI8SQR/wv2t2sL7mIAA/e2Y9yzbWcvn8iZwxY2RLmWSNIFkLACgP2/0LCoyB4Rl/tj6CZLJQH4FI/CgR5KmqHQc45z+eZNnGWp6t2kl5aREL3jqWJ9fWkHCYMXpwS7s+wJQRgwAYNih1M1j6paADw+ahbImgtEh9BCJxpUSQpx59dTsbdh7kgwv/yuKVbzJ/6nBOGD+0Zf2UkcGB/x/PnQ7AyZMrABiedldweqIYFHYYZxsRtCjsO1CFQCR+dNVQnlq2MbjyJ+Gw62ADsyZUcPy41CBwU8MawOfPm8EnTp/K8LAmkF4jSNdRjSC5vECZQCR2VCPIQ03NCZ7fsItL51S2LDthfDAcdFLyBrDiwoKWJADBswIySfYRFGVJBNmWi0j/pxpBHvnFkjdYvGo7lRUD2FffxIUnjmVQaRGPvrqd06ePpKy4gEvmVDJt1KCs28jW2Vsa3jFclOXy0cLwaiJ1FovEjxJBHnhmXQ1f/f1KNu461LJs9sQK3jVzDOcdP4ZvvPeElqabWz48u8PtXTqnkmmjy49Y1pIIslw+mqwRKA2IxI8SQY41NCX42B3P437k8vfOGo+ZkeUEvl03Z0gWyauCstcI1FksElfqI8ixVVv34g5ffOexvPi1d7Usn97qjP5olRYnawTt9xEoEYjEjxJBjr20aQ8AH37bRIYPKuH8mWMoKSxg1oSKHv2cZNNQ1quGkpePqnFIJHbUNJQjL7yxmw8uXALA+KFljB0ajBH0w8vmsLeuseWqoJ6SahrqoI9AeUAkdpQIcuSfHljeMv3Zc6a3TA8oKUwNANeDkjeSZWsaarlqqMc/WUTynRJBDmzefYjNu+v4/LnTuXz+JMYNLev4TUeppIOmoWSCSHjG1SLSj0XaR2BmF5rZWjOrMrPrM6wfZma/M7OXzex5MzsxynjyxRnffQKAS+ZUMr5iQK9cu18S9gFkrxEkE4EygUjcRJYIzKwQuA24CJgJXG5mM1sV+1dgubufBHwM+GFU8eTa5t2HuPK/n+fBF6tblk0dmf3GsJ6WbBrK1hmcTBDNqhKIxE6UTUPzgSp3Xw9gZvcBFwOvppWZCfw7gLuvMbMpZjbG3bdHGFdOPPjiFp5YW8MTa2sA+N1n396rd/EWh01D2c741UksEl9RNg1VApvT5qvDZelWAJcCmNl8YDIwofWGzOwqM1tqZktramoiCjdaa97cd8T8ST18eWhHSgqTiSDzeg02JxJfUSaCTEeW1oeh7wDDzGw58HngJaCpzZvcb3f3ee4+b9SoUT0faS9Y++Z+3nn8GI4dU84Vp07O2mkblWSNwNUHICKtRNk0VA1MTJufAGxNL+Du+4ArASxoJ9kQ/vUb7s4tj61j/c6DvGfWeG6/Yi4FORjpM9lZnC0NJGsEyhMi8RNlIngBmGFmU4EtwGXAR9ILmFkFcMjdG4BPAU+HyaFfaGhKcPnPnmt5tsD7Zo/PSRKA7A+kSVLLkEh8RZYI3L3JzK4BFgOFwB3uvsrMrg7XLwSOB+42s2aCTuR/iCqeXPjV3zaybGMtU0YM5Bf/cErLc4VzIXXGn6WzuDeDEZG8EukNZe6+CFjUatnCtOklwIwoY8iVpuYEtzy2jrmTh/Gbq0/Lm3H+szYNFSSbjtQ2JBI3urO4h7k7//bH1RxuamZvXSOfPH1qXiSBjkLIfYQikitKBD3syddq+Pmzqf7uM48dmcNo2srWGZwPyUpEckPDUPewP768rWX6XTPHMLisZ0cRjYrygEh8qUbQw1Zt3ceZx47i5x+f1+GVOr2pozN+PYdAJL7y50jVxyUSzjf/ZxWrt+1jzsSKvEoC6bLfRxCuV1+xSOyoRtBDzvzeE1TX1nHMqEF8+sxjch1OG2+tHArAghPHZlyvpiGR+FIi6AGLXtlGdW0dAPd86hTKS/Pva506chDrb1yQ9Ya2ZNORKgQi8ZOf7Rd9zGOrg8FSn/ry2YwbOiDH0WTX3l3NqhCIxJcSwVFa+sZunl23k7mThzF5RO89X6Cn6fJRkfhSIjgKm3Yd4gMLl7Bj/2E+esqkXIdzVFKdxWocEokbJYKj8J1HVgMwbmgZF89u/aiFvkUVApH4yr9ezT6i9mADi155kxmjy3n0n87KdThHTQ+mEYkv1Qi66ZmqnQDcsOC4HEciInJ0lAi6obE5wU1/WsOUEQM5Y0bffGJaa+osFokvJYJuWLF5D1v21PGlC96St3cQd1VLZ3FuwxCRHOgfR7Fe5O5c9YtlALxjen6NLHo0NNaQSHwpEXTRQyu2svtgA2+bMoyKgSW5DqfHtLQMqUogEjtKBF3wyMo3ufa+5VRWDOD+q07LdTg9KkePUhaRPKBE0AW/XroZgNs+enLOHkIfnf62PyLSWUoEnbS/vpEV1Xs4f+YYZk+syHU4PU6dxSLxpUTQCTsPHOa87z/FzgMNXD6/bw8lkY0uHxWJLyWCTvinB1awY/9hAM5+S/+4b6A1a/UqIvERaSIwswvNbK2ZVZnZ9RnWDzWz/zGzFWa2ysyujDKe7mhoSvDMuhoA7r/q1H575lwQ/ktQ05BI/ESWCMysELgNuAiYCVxuZjNbFfsc8Kq7zwLOBr5vZnl1TebL1Xtwh4V/fzKnHDMi1+FERvcRiMRXlDWC+UCVu6939wbgPuDiVmUcGGzBaXY5sBtoijCmLntu/S4A5k/tv0kAUvcRaBhqkfiJMhFUApvT5qvDZeluBY4HtgKvANe6e6L1hszsKjNbamZLa2pqooq3jbqGZu752yZmTaxg+KC8qqj0uP7a5CUiHYsyEWQ6srQ+3bwAWA6MB2YDt5rZkDZvcr/d3ee5+7xRo3qvs3bNm/vYtreej506udc+M1eUBkTiK8pEUA1MTJufQHDmn+5K4EEPVAEbgLwZ1/n1moMAnFDZJjf1OwV6eL1IbEWZCF4AZpjZ1LAD+DLgoVZlNgHnAZjZGOAtwPoIY+q05oRzy6OvMbK8lOmjynMdTuTUMiQSX5E9oczdm8zsGmAxUAjc4e6rzOzqcP1C4NvAnWb2CkHrxHXuvjOqmLrisdXb2bKnjls+PIuifjLUdHtSncW5jUNEel+kj6p090XAolbLFqZNbwXOjzKG7vpr1U4GlhTynpPG5zqUXqHLR0Xiq/+f6nbT82/UcvKkYf3mwTMdSdYI1EQkEj/xOMp1UdWO/azeto93zOg/D57pSEtnsZqGRGJHiSCDZ9YF3RTvOWlcjiPpPaoJiMSXEkEGD7+8jWmjBjFh2MBch9JrUsNQq0ogEjdKBK3UNzazbGMt745JJ3GKqgQicaVE0Mpr2/cDMG3UoBxH0rvUNCQSX0oErTz9WjCW0Tumx6ejGNRZLBJnSgStLNtYy4zR5YwoL811KL1KFQKR+FIiSJNIOC9t3sPJk4blOpReV6C2IZHYUiJIs37nQfYcamTu5PglAuUBkfhSIkjz4sZaAE6eXJHjSEREeo8SQZoXN9UydEAxx4zs/6ONtqbOYpH4UiJIs3zzHmZPrKCgIH7tJGoaEokvJYJQc8JZv/Mgx46JX20A1FksEmdKBKGte+poaEowLQYPoclEeUAkvpQIQkte3wXAiZVDcxxJbigPiMSXEkHoN8uqmTR8ICeM7//PJ87EWjqL1VssEjdKBAQ3kr2yZS/vPH5MywExbmK62yKCEgEAL22upa6xmbdOiGdtANQ0JBJnSgTAs+uC/oFzjxuT40hyR1cNicSXEgGwcfdBxg4pY+iA4lyHkjPKAyLxpUQAbNp1iEkj4vM0skxa7izOcRwi0vuUCICNuw8xaXi8E4GIxFekicDMLjSztWZWZWbXZ1j/ZTNbHv6tNLNmMxseZUytHWpoomb/YSbHPBGoaUgkvjqVCMzsEjMbmjZfYWbv6+A9hcBtwEXATOByM5uZXsbdv+fus919NnAD8JS77+7qThyNTbsPAahpSIPOicRWZ2sEX3f3vckZd98DfL2D98wHqtx9vbs3APcBF7dT/nLg3k7G02M27goSweQR8XpGcWuqEYjEV2cTQaZyRR28pxLYnDZfHS5rw8wGAhcCv82y/iozW2pmS2tqajoRbudt2HkQgCkxrxEkubqLRWKns4lgqZndbGbTzOwYM7sFWNbBezKdY2Y7yvwd8JdszULufru7z3P3eaNGjepkyJ2zfNMeJg4fQMXAkh7dbl9juqVMJLY6mwg+DzQA9wMPAHXA5zp4TzUwMW1+ArA1S9nLyEGzUH1jM3+p2sn8KSN6+6PzjmoCIvHVUfMOAO5+EGhz1U8HXgBmmNlUYAvBwf4jrQuFndBnAX/fxe0ftb9t2M3+w02cc1zP1jJERPqSzl419KiZVaTNDzOzxe29x92bgGuAxcBq4AF3X2VmV5vZ1WlFLwH+HCabXvX0a0F/w5nHKhGoaUgkvjpVIwBGhlcKAeDutWY2uqM3ufsiYFGrZQtbzd8J3NnJOHrUmjf38dbKoQwpi+/QEq3p8lGR+OlsH0HCzCYlZ8xsCn18NIK9hxr52/rdzJ5Y0XHhGNDloyLx1dkawVeAZ83sqXD+TOCqaELqHUvW76Ip4Zx7fIcVGxGRfq2zncWPmNk8goP/cuAPBFcO9VnPrd9FaVEBpx2jK4bS9elqnoh0S6cSgZl9CriW4BLQ5cCpwBLg3OhCi1bVjgMcN3YwZcWFuQ4lL6hlSCS+OttHcC3wNmCju58DzAF69hbfXrZux36mjx6c6zDyRsXAEooLjRsuOi7XoYhIL+tsH0G9u9ebGWZW6u5rzOwtkUYWob11jWzfd5gZY8pzHUreKCkqYN3/W5DrMEQkBzqbCKrD+wh+DzxqZrVkv0s471XtOADA9FFKBCIine0sviSc/IaZPQEMBR6JLKqIVdcmRxzVQHMiIp2tEbRw96c6LpXf3txbD8DYoWU5jkREJPdi+ajKbXvrKS8tYrDuKBYRiWci2LG/njFDSnMdhohIXohlIqg92MiwmD9/QEQkKZaJYP/hRgaXdbl7RESkX4plIjhQ36T+ARGRUCwTwf76JtUIRERCsU0E5UoEIiJADBNBfWMzDc0JPYxGRCQUq9PiC255mjNmjASgvDRWuy4iklWsjoZrt+9n7fb9AAwo0fDTIiIQw6ahpNKi2O66iMgRYns0LC1SjUBEBOKcCIpju+siIkeI7dFQTUMiIoFIj4ZmdqGZrTWzKjO7PkuZs81suZmtMrNeG+JaTUMiIoHIrhoys0LgNuBdQDXwgpk95O6vppWpAP4TuNDdN5nZ6KjiaU01AhGRQJRHw/lAlbuvd/cG4D7g4lZlPgI86O6bANx9R4TxHKFMfQQiIkC0iaAS2Jw2Xx0uS3csMMzMnjSzZWb2sUwbMrOrzGypmS2tqanpkeDUNCQiEogyEViGZd5qvgiYC7wbuAD4mpkd2+ZN7re7+zx3nzdq1KgeCU5NQyIigSjvLK4GJqbNTwC2Ziiz090PAgfN7GlgFvBahHEBqhGIiCRFeVr8AjDDzKaaWQlwGfBQqzJ/AM4wsyIzGwicAqyOMKYWuo9ARCQQWY3A3ZvM7BpgMVAI3OHuq8zs6nD9QndfbWaPAC8DCeC/3H1lVDGlKylUIhARgYgHnXP3RcCiVssWtpr/HvC9KONoray4gIKCTF0YIiLxE8vT4vrGRK5DEBHJG7FMBCIikqJEICISc7FMBHMnD8t1CCIieSOWieCyt03suJCISEzEMhEUmK4YEhFJimciiOVei4hkFstDomUcBklEJJ7imQiUB0REWsQyEaiPQEQkJZaJQHlARCQllolANQKRbvrRj2DmTBgwIDij+sEP2i//iU8E5d544+g+9+yzoz+D66lY+6BIB53LVxpvTqQb7rsPrr0W5syBL3wBSkvh1FNzHVX0fvMbeOopWL4cVqyA/fvhox+FX/4y15H1mFgmAlONQKTrHn449Tp+fG5j6U3/9m9BAigvhwkTYM2aXEfU42LTNOSeekqm0oBIN2wNHzAYpyQAcMst8NprsG8f/OQnuY4mErFJBOnURyCRu/NOeP/74Zhjgvb0IUPg9NPbb07YvRu+8hU48UQYOBCGDoVZs+D66+Hgwe6XzebwYfjOd+Ckk4JtDBkCZ5wBDzxwZLlvfCNoO3/iiWDeLPXXXd35fpIxf/WrMHVq0DQ1bRp885vQ0JC5/Jo1Qdv/xIlB+TFj4CMfgbVrOx/rOefAjBn9+iqT2DQNpVUIdGexRO8znwk6Vc88E8aNg127YNEiuOKK4CD07W8fWX7DhuCAs3EjzJ0bvD+RCM5Eb7kFrr4aBg3qetlsGhrggguCtu/jjoPPfQ4OHQrawz/84aA9/MYbg7Jnnx283nln8Jlf/3rvfz9JH/oQvPACfOADUFwMf/hDkKiWLoWHHjryYP3II3DppdDYCH/3dzB9OlRXw4MPwh//GCS2k08++n3pD9y9T/3NnTvXu6OpOeGTr3vYJ1/3sP/v6u3d2oZIp1VVtV12+LD7uee6FxW5V1cfue7tb3cH9xtvbPu+mhr3urrulc3mxhuDbVx0kXtjY2r59u3ukycH6/7ylyPfc9ZZwfKu+PjHg/ds2HDk8q5+P8nPnjHDfffu1PK6OvdTTw3W3X13avnu3e4VFe4jRrivWnXktlaudB80yH3OnM7Fmu6JJ4IyH/1o9jJ5CljqWY6rsTw37sc1PMkX06a1XVZSEpx5NzXB44+nli9bBn/9K8yeDddd1/Z9I0dCWVnXy7bnjjuC/wg33wxFaQ0Do0fD174WTP/Xf3W8ne7qyveT7mtfg2Fpw8iXlcG//3swfccdqeV33w179gTNRjNnHrmNE06AT38aXnoJXn316Pajn4hR01CqbUh9BBK5TZvgppuCA9qmTVBXd+T6LVtS0889F7xecEHH7ZZdKZvN/v1QVQWVlUGzUGvnnhu8vvRS97bfGV35ftKddVbbZWecESSz9HiXLAleV6wImo5ae+214HX16raJIoZikwgeW72jZVqJQCK1fj3Mnw+1tcFB6vzzg87cwsLgZqW77go6PZP27AleKys73nZXymazd2/wOm5c5vXJ5cnP6mld/X7SjRnTdllhIYwYATtS/8fZtSt4/dnP2o/lwIFu7UJ/E5tEcLipuWVaeUAidfPNwYHov/87uGIl3b33Bge6dBUVwWu2s+Duls1m6NDg9c03M6/ftu3Icj2tq99Puu3bYdKkI5c1NwfbGzIktSwZ+4oVwVVR0q5I+wjM7EIzW2tmVWZ2fYb1Z5vZXjNbHv793yjjSX1ub3yKxFZVVfD6/ve3XffUU22XJe/OXbw4uPqnPV0pm83gwUEb/ZYtsG5d2/XJy0SjuqKmq99PR+ufeSboV5gzJ7Us+T0980z3YoyZyBKBmRUCtwEXATOBy80sU2PcM+4+O/z7VlTxpFPTkERqypTg9cknj1y+eHHmDti5c+Htbw8u2bzpprbrd+2C+vqul23PJz8ZXFP95S8HZ9RJO3emLt385Cc73k53dPX7SfftbwdNSkn19XDDDcH0lVemll95ZVB7+uY34fnn224nkWj7+TEWZdPQfKDK3dcDmNl9wMVAzrvplQYkUp/9bNDs8cEPBme9lZWwcmVwXfuHPgT339/2Pb/8ZXC9/r/+K/z2t8G0e3DG/uc/BzdGJQ+gXSmbzZe+BH/6U3Ad/qxZsGBBcB/Br38dtLX/y7/AO97Rk99KSne+n6Tjjw+u+km/j+D11+Hd7w7uQUgaMSK4J+KSS4LawXnnBe8rKAg6p5cs6XzS/P3vgz9INactWZJq1ho5Ev7jP7r1VeSLKBNBJbA5bb4aOCVDudPMbAWwFfiSu69qXcDMrgKuApjUun2wk9LHFyrQqHMSpZNOCppXvvrV4CappqbgYPvgg8FZaqYD3dSp8OKL8N3vBgedW28NLo2cMgX++Z+Dyzq7UzabkhJ49NGgvf5Xv4If/zi48mbWrGBE0csv76lvo63ufD9JDzwQ1AruuScY8qKyMrgq6Prr27b5nncevPxycJBevDhoJiopCYbIOPfczE1TmSxf3rbfYv364A9g8uQ+nwgs/bLKHt2w2QeBC9z9U+H8FcB8d/98WpkhQMLdD5jZAuCH7j6jve3OmzfPly5d2uV4HlqxlX+8N7i87LefOY25k4d3eRsiIn2VmS1z93mZ1kXZWVwNTEybn0Bw1t/C3fe5+4FwehFQbGYjowgm/VxBo4+KiKREmQheAGaY2VQzKwEuAx5KL2BmYy08KpvZ/DCeXVEEk37sVxoQEUmJrI/A3ZvM7BpgMVAI3OHuq8zs6nD9QuADwGfMrAmoAy7zqNqq0uiqIRGRlEhvKAubexa1WrYwbfpW4NYoY8hEiUBEJCU2g85ZWoOQ8oCISEp8EoFlnhYRibvYJIJ0ahoSEUmJTSI48vLRnIUhIpJ3YpMI0qlGICKSEptEkH7s1wgTIiIpsUkE6XRnsYhISowSgWWYEhGR2CSCI5uGlApERJJikwjSKRGIiKTEMhEoD4iIpMQmEeg+AhGRzOKTCNKfUKZMICLSIjaJIJ0SgYhISmwSgZqGREQyi00iSKdEICKSEstEoKYhEZGU2CQCPbNYRCSzWCYC1QhERFJikwjSKRGIiKTEJhEc8czi2Oy1iEjHYnlIVH1ARCQlPolAfQQiIhlFmgjM7EIzW2tmVWZ2fTvl3mZmzWb2gchiSZtWIhARSYksEZhZIXAbcBEwE7jczGZmKXcTsDiqWNp+Zm99kohI/ouyRjAfqHL39e7eANwHXJyh3OeB31mogzkAAAbwSURBVAI7IozlCEoEIiIpUSaCSmBz2nx1uKyFmVUClwAL29uQmV1lZkvNbGlNTU23gtHooyIimUWZCDIdbb3V/A+A69y9ub0Nufvt7j7P3eeNGjXqqANTIhARSSmKcNvVwMS0+QnA1lZl5gH3hWfrI4EFZtbk7r/v6WAsy7SISNxFmQheAGaY2VRgC3AZ8JH0Au4+NTltZncCD0eRBILtZ54WEYm7yBKBuzeZ2TUEVwMVAne4+yozuzpc326/QJRMmUBEpEWUNQLcfRGwqNWyjAnA3T8RZSwiIpJZbO4sNvUMiIhkFJtEUFigRCAikkmkTUP55JSpwzl+3BA+PG9CrkMREckrsUkEBQXGn649I9dhiIjkndg0DYmISGZKBCIiMadEICISc0oEIiIxp0QgIhJzSgQiIjGnRCAiEnNKBCIiMWfurZ8Vk9/MrAbY2M23jwR29mA4uaR9yU/9ZV/6y36A9iVpsrtnfLJXn0sER8PMlrr7vFzH0RO0L/mpv+xLf9kP0L50hpqGRERiTolARCTm4pYIbs91AD1I+5Kf+su+9Jf9AO1Lh2LVRyAiIm3FrUYgIiKtKBGIiMRcbBKBmV1oZmvNrMrMrs91PB0xszfM7BUzW25mS8Nlw83sUTNbF74OSyt/Q7hva83sgtxFDmZ2h5ntMLOVacu6HLuZzQ2/gyoz+5GZ9frzRrPsyzfMbEv42yw3swX5vi9mNtHMnjCz1Wa2ysyuDZf3ud+lnX3pi79LmZk9b2Yrwn35Zri8d38Xd+/3f0Ah8DpwDFACrABm5jquDmJ+AxjZatl3gevD6euBm8LpmeE+lQJTw30tzGHsZwInAyuPJnbgeeA0wIA/ARflyb58A/hShrJ5uy/AOODkcHow8FoYb5/7XdrZl774uxhQHk4XA38DTu3t3yUuNYL5QJW7r3f3BuA+4OIcx9QdFwN3hdN3Ae9LW36fux929w1AFcE+54S7Pw3sbrW4S7Gb2ThgiLsv8eBf+d1p7+k1WfYlm7zdF3ff5u4vhtP7gdVAJX3wd2lnX7LJ531xdz8QzhaHf04v/y5xSQSVwOa0+Wra/4eTDxz4s5ktM7OrwmVj3H0bBP8ZgNHh8r6wf12NvTKcbr08X1xjZi+HTUfJanuf2BczmwLMITj77NO/S6t9gT74u5hZoZktB3YAj7p7r/8ucUkEmdrK8v262dPd/WTgIuBzZnZmO2X74v4lZYs9n/fpJ8A0YDawDfh+uDzv98XMyoHfAl9w933tFc2wLN/3pU/+Lu7e7O6zgQkEZ/cntlM8kn2JSyKoBiamzU8AtuYolk5x963h6w7gdwRNPdvDKiDh646weF/Yv67GXh1Ot16ec+6+PfzPmwB+RqoZLq/3xcyKCQ6c97j7g+HiPvm7ZNqXvvq7JLn7HuBJ4EJ6+XeJSyJ4AZhhZlPNrAS4DHgoxzFlZWaDzGxwcho4H1hJEPPHw2IfB/4QTj8EXGZmpWY2FZhB0HGUT7oUe1gd3m9mp4ZXP3ws7T05lfwPGrqE4LeBPN6X8HN/Dqx295vTVvW53yXbvvTR32WUmVWE0wOAdwJr6O3fpTd7yHP5BywguLrgdeAruY6ng1iPIbgyYAWwKhkvMAJ4HFgXvg5Pe89Xwn1bSw6urmkV/70EVfNGgjOVf+hO7MA8gv/MrwO3Et4Jnwf78gvgFeDl8D/muHzfF+AdBE0FLwPLw78FffF3aWdf+uLvchLwUhjzSuD/hst79XfREBMiIjEXl6YhERHJQolARCTmlAhERGJOiUBEJOaUCEREYk6JQKQXmdnZZvZwruMQSadEICISc0oEIhmY2d+H48QvN7OfhgODHTCz75vZi2b2uJmNCsvONrPnwsHOfpcc7MzMppvZY+FY8y+a2bRw8+Vm9hszW2Nm9/T2GPgirSkRiLRiZscDHyYY+G820Ax8FBgEvOjBYIBPAV8P33I3cJ27n0RwZ2ty+T3Abe4+C3g7wR3KEIyW+QWCseWPAU6PfKdE2lGU6wBE8tB5wFzghfBkfQDBoF8J4P6wzC+BB81sKFDh7k+Fy+8Cfh2OFVXp7r8DcPd6gHB7z7t7dTi/HJgCPBv9bolkpkQg0pYBd7n7DUcsNPtaq3Ltjc/SXnPP4bTpZvT/UHJMTUMibT0OfMDMRkPL82MnE/x/+UBY5iPAs+6+F6g1szPC5VcAT3kwPn61mb0v3EapmQ3s1b0Q6SSdiYi04u6vmtlXCZ4QV0Aw8ujngIPACWa2DNhL0I8AwTDBC8MD/XrgynD5FcBPzexb4TY+2Iu7IdJpGn1UpJPM7IC7l+c6DpGepqYhEZGYU41ARCTmVCMQEYk5JQIRkZhTIhARiTklAhGRmFMiEBGJuf8P61gqkjLHR0EAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(axis,acc[0])\n",
    "plt.text(1500, 0.5, 'acc of label1' , fontdict={'size': 20, 'color': 'red'})\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(axis,acc[1])\n",
    "plt.text(1500, 0.5, 'acc of label2' , fontdict={'size': 20, 'color': 'red'})\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(axis,acc[2])\n",
    "plt.text(1500, 0.5, 'acc of label3' , fontdict={'size': 20, 'color': 'red'})\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(axis,acc[3])\n",
    "plt.text(1500, 0.5, 'acc of label4' , fontdict={'size': 20, 'color': 'red'})\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhdVb3/8fc3SZM2bZp0SAfSIS0UaCmlhVIrQ5m80OL1ojiBP1ArWrmCF716FVF+4OX+nB5B8cJjrYqIcEFBUNReCjIjZeiQQkcILW3TMR3TKUmTfH9/7J3m5OSkSUp2zvR5PU+es4e19/nuc9r9PWutvdc2d0dERCReTrIDEBGR1KQEISIiCSlBiIhIQkoQIiKSkBKEiIgklJfsALrT4MGDvby8PNlhiIikjcWLF+9w99JE6zIqQZSXl7No0aJkhyEikjbMbH1769TEJCIiCSlBiIhIQkoQIiKSkBKEiIgkpAQhIiIJRZYgzOweM9tuZsvbWW9m9jMzqzSzN8zs9Jh1M81sTbjuxqhiFBGR9kVZg7gXmHmU9bOAceHfHODnAGaWC9wdrp8AXGlmEyKMU0REEojsPgh3f8HMyo9S5DLgPg/GG3/FzErMbDhQDlS6+1oAM3soLLsyqlhFssmBuga276tLdhgpxd15/q1qdh+oT3Yox6SwII9rzzu+2/ebzBvlyoCNMfNV4bJEy9/X3k7MbA5BDYRRo0Z1f5SSNfbXNdD8fBQHXnxrBzsPJD6Rbtlby+J3d1Pf2NSDEb53DizbuCfZYaQ0s2RH0HWD+xVkXIJI9DX4UZYn5O7zgHkAU6dO1dOPstzhxiZeeKua+obWJ+4Nuw6yZMNu2jufr63ez9odB7r0XkUFeUwZPeBYQ02af5owlPeNGcjgfgXJDiWlDOqXzzknDMbSMUNEJJkJogoYGTM/AtgM5LezXLLInoP1vL19P8s27uGd6kQnbueVtbvYsvdQq6W1h9v/RZ+bY5w0tCjhut69cvnYGSM4eVjL+gGF+cw4sZScds4XxX16kZerCwElcyUzQTwOXB/2MbwP2OvuW8ysGhhnZmOATcAVwKeSGKe8B9v31XKgrpHdB+t5uXIH9Q1NHKxv5KXKHeyva2h3u6rdrU/8pUVtf+0W5OUwa+JwhsStKx/clymjStqULx/Ul969co/xSESyT2QJwsweBM4HBptZFXAL0AvA3ecC84FLgUrgIDA7XNdgZtcDC4Bc4B53XxFVnNJ9mpqcnBzjcGMTD7yynocXV7Fic02rMs2196KCPM4dV0pBr8S/wM8+PoczxwxkxIA+nFk+kNz2fsaLSGSivIrpyg7WO3BdO+vmEyQQSQMH6xv4+sPLeHZ1NaePLmH9zoNU7T5Ebo7xz5OGc/5JQ8jLMSaWFXPCkH7JDldEOimjhvuW7tHU5FRW72fn/nqWbNjN7LPLKcwP/qm4O8uq9lLf0MSbm/byyOIqVm1pqSXs3F9P/969+OKM4Xz1n05Uk45IGlOCEF5Zu5OfPPUW8z49lZ3767hv4XruffndI+v/sGgjD35hOnf+/W0eX7aZQ4cbW23fu1cO//kvE/nEmSMRkcyhBCF8/eFlVO0+xGnffbLV8jkzxvLyOztYvqmGbz36Js+/Vc2ogYVcfnrZkX6BqaMH6EoekQylBCGcNLSIqt2HuPDkIUwZWcLowX258OQh9CvI47V1u/jELxby/FvVXHTyEH792TOTHa6I9BAlCMGBU8uKuSfByT/28tLRg/r2YFQikmxqGxD21zVQmJ+4M7mkT6+W6cJeCcuISGZSghAO1jfQryBxZTL2KqT2koiIZCYlCOFAXSOF7SSI/LyWfyK6WU0kuyhBCAfqGuhXkLh2EJsUlB5EsosSRIara2hk11HGuL/jyTXhswE6Pv1rlEuR7KIEkeFm/OhZTr/tKRas2Npm3cvv7OBnz1QC0L9Pxxe0KT+IZBdd5prB3tq2j201wQNvrr1/MZPKillWtZc3b72Yot69+MuyLQDMu/oMph8/qN395OfmUN/YpCYmkSyjGkSGmf/mFn790joam5wHX9sAwM3/PIH83ByWVe0F4Nk11RxubOKPS6ooH1TIxacMo3/v9i9hPVJzUBVCJKuoBpFBDjc28aUHlgCwYvNe9tc2MLy4N9ecM4YPTz6Og/WNnPujZ/m3B5dS1DuP+oYm5szo+DGFzY/p00VMItlFNYgM8uraXUemH12yib+v2sb44f0BGNSvgJEDCznvxFIA9tU2MLa0LzMnDuv0/k2NTCJZRTWIDPLM6u307pXDY186m1l3vkiTw4gBfVqV+eFHJ1G9r45TRxR3er9qYRLJTqpBpLmq3Qcpv/Fv/OrFtWzZe4iykj6MH96fWWHNYMa40lblhxX37lJyiKX8IJJdVINIY7WHGznnh88C8F9/W8X0sQMZ2DcfgO9ffipnHT+IC04e0m3vpxqESHZRDSKNvfj2jlbzG3YeZEBhkCBKCvO5+v3l3To8hvogRLKLEkQaW7/zAAC3fXgiAJv31h5JEJFQfhDJKpEmCDObaWZrzKzSzG5MsH6AmT1mZm+Y2WtmNjFm3VfNbIWZLTezB82sd5SxpqMte2vp0yuXSWUtfQoD+kaXIHLUxiSSVSJLEGaWC9wNzAImAFea2YS4YjcBFe4+Cfg0cGe4bRnwb8BUd58I5AJXRBVrutpaU8uw4t6cclz/I8sGRPjMBqUHkewSZQ1iGlDp7mvdvR54CLgsrswE4GkAd18NlJvZ0HBdHtDHzPKAQmBzhLGmjX9U7uCrv6+gqcnZtreWYf17k5ebc6QDOcomJlUgRLJLlFcxlQEbY+argPfFlVkGXA68ZGbTgNHACHdfbGY/BjYAh4An3f3JRG9iZnOAOQCjRo3q3iNIQTc8VMGO/XXsPXSYLXtrmTZmYKv1Rb27/yttTgxKECLZJcoaRKLTicfN/wAYYGYVwJeBpUCDmQ0gqG2MAY4D+prZVYnexN3nuftUd59aWlqaqEhGab4o6ZnV29m05xBD+wddM89//QLmzBjLByYMPcrW742uYhLJLlEmiCpgZMz8COKaidy9xt1nu/tkgj6IUmAd8AFgnbtXu/th4FHgrAhjTQtNTc6uA/VcGHNvw/DiIEGMGlTITZeOp1du93+lHqZ11SBEskuUCeJ1YJyZjTGzfIJO5sdjC5hZSbgO4PPAC+5eQ9C0NN3MCi14Ss1FwKoIY00Luw/W09DknDtuMCVhZ3RzDaIn6IFBItklsgTh7g3A9cACgpP7H9x9hZlda2bXhsXGAyvMbDXB1U43hNu+CjwCLAHeDOOcF1Ws6WLtjuC+h1EDC/nqB04kL8c4aVhRj72/0oNIdol0qA13nw/Mj1s2N2Z6ITCunW1vAW6JMr508Zt/rOORxVVcc84YAMYM7stF44dy5bRR5OdFf6+jOqlFspPGYkoD3/3LSgBefmcnAIP6FgD0SHKIpU5qkeyiBJHCvvr7iiOD7wH8uWITuTnWqedHR0E1CJHsogSRouoaGnls6aZWyw43OoP75Sets1j5QSS7aLC+FFVzqKHV/Lgh/YBglNZk0VVMItlFCSJF7T10+Mj06aNKGNI/6HeIcqyljig/iGQXJYgUVVMbJIjbLjuFX3/mTE4oTYEaRNLeWUSSQQkiRTXXIE4pK2ZA33xKi4IaRFFB8rqN1MQkkl2UIFJUTZgg+vcOmpSah7vo36fnm5iaL29VehDJLkoQKao5QRSHCeHQ4UYAJsY8HKinqQIhkl10mWuKam5iah6++4vnHU+/3nl8ePJxPR6Lh4Pw6olyItlFCSJF1dQ2UJCXQ+9euUBQk/jS+SckNyjlB5GsogSRYq793WKq99cxdnDfIyO2Jpv6IESykxJEinlixVYA3qnez+hBfZMcTWu6ikkku6iTOoU0NrU8cG/PwcMcV9xzz3roDKUHkeyiBJFC3t15oNX8sFRLEMoQIllFCSKFrNxcA3DkuQ/nnzTkaMV7nK5iEsku6oNIAU+t3MaIAX1YuaWGXrnGN2aexL//04n0TeJd04koPYhkl9Q6A2WhuoZGvnDfIvJyjItPGcrIgYUU5OWSYrkhoAwhklXUxJRkG3cdBKChydm5v55BfZM3GF9H9EQ5keyiBJFkVbsPHZl+dd2upI7W2hF1QYhkl0gThJnNNLM1ZlZpZjcmWD/AzB4zszfM7DUzmxizrsTMHjGz1Wa2yszeH2WsyRKbICC5z3toT3NiUH4QyS6RJQgzywXuBmYBE4ArzWxCXLGbgAp3nwR8GrgzZt2dwBPufjJwGrAqqliTqW2CSL0aRPNIsjk5ShEi2STKrtBpQKW7rwUws4eAy4CVMWUmAN8HcPfVZlZuZkOBQ8AM4LPhunqgPsJYe9yfKzZxoK6Rqt0HGT2okBwz1u04wICU7oMQkWwSZRNTGbAxZr4qXBZrGXA5gJlNA0YDI4CxQDXwGzNbama/MrOE406Y2RwzW2Rmi6qrq7v7GCJzw0MV3PTYm2zac4gRA/rwyTNHAvDBU4cnObL2qQ9CJLtEmSASnU48bv4HwAAzqwC+DCwFGghqNqcDP3f3KcABoE0fBoC7z3P3qe4+tbS0tNuCj1JTzJAaSzfsYURJIV+cMZZV/zmTkQMLkxhZYi2JQRlCJJtE2cRUBYyMmR8BbI4t4O41wGwAC0aCWxf+FQJV7v5qWPQR2kkQ6WhLTW2r+ROHFWFm9MnPTVJEnaMahEh2ibIG8TowzszGmFk+cAXweGyB8Eql5kb3zwMvuHuNu28FNprZSeG6i2jdd5HWtuwJOqZPGNIPgLGlqTVqa3uUH0SyS2Q1CHdvMLPrgQVALnCPu68ws2vD9XOB8cB9ZtZIkACuidnFl4EHwgSylrCmkc7erNpLRdWeI5ey3nnFZLbX1HH+ienRNKaxmESyS6QDOrj7fGB+3LK5MdMLgXHtbFsBTI0yvp72obteAuBbs04GoKykD6ccl7xnTHeV8oNIdtGd1EmwZMNuCvJyKO6TejfFHY2G2hDJLkoQPeRwY9OR6ZcrdzKsuHfaPaEtzcIVkfdICaKH1Bw6fGR6X10DQ4oKkhiNiEjHlCB6yJ6YBAGk9KB88ZorDqpBiGQXJYgesudgXIJIo/6H5tv6dBWTSHZRgughzU1MYwcH9zyUpOCorR1RfhDJLkoQPWT3wWCswTFhgijqnYYJQlcxiWQVJYgesH1fLTv3BwmibEAfAJo8fliq1KU+CJHslIpPPs4oldv38YE7XiAvxyjIy+Hy00fw9KrtzEiTu6djKT+IZBcliIi9u6PlmdPDinszeWQJ/7jxwiRHdWxUgxDJLmpiitjOA3VHpkvT/N6HdLuxT0TeGyWIiFXva0kQ/QrSu8Km9CCSXZQgItacIEYNLOTbHxyf5GjeG9UgRLJLev+kTQPb99VxwpB+/P3fz0t2KO+Z0oNIdlENImLbamoZ2j+9+x6aqQIhkl2UICK2raaOoUW9kx1Gt9CNciLZRQkiQu7O9n21DOmfIQlC+UEkqyhBRGj3wcMcbnQ1MYlIWlIndQTcnf9+ppIThvQDYGjG1CCUIUSyiRJEBKr31XHHU28dmc+YGkSyAxCRHhVpE5OZzTSzNWZWaWY3Jlg/wMweM7M3zOw1M5sYtz7XzJaa2V+jjLO7baupazU/JM07qZtrDqpAiGSXyBKEmeUCdwOzgAnAlWY2Ia7YTUCFu08CPg3cGbf+BmBVVDFGZWtNbav54cXpnSCa6SomkewSZQ1iGlDp7mvdvR54CLgsrswE4GkAd18NlJvZUAAzGwF8EPhVhDFGYltMghhQ2Iu83My4FkA1CJHsEuWZqwzYGDNfFS6LtQy4HMDMpgGjgRHhup8C3wCajvYmZjbHzBaZ2aLq6uruiPs9a04QM08Zxs+unJLkaLqPEoRIdokyQSQ6ncQ/JecHwAAzqwC+DCwFGszsn4Ht7r64ozdx93nuPtXdp5aWJv8ZC+7Ow4uqGFJUwNyrz+DcccmPqbuoiUkku0R5FVMVMDJmfgSwObaAu9cAswEs6AldF/5dAfyLmV0K9Ab6m9n97n5VhPF2i2VVe9laU8tnzypPdijdTjUIkewSZQ3idWCcmY0xs3yCk/7jsQXMrCRcB/B54AV3r3H3b7n7CHcvD7d7Jh2SA8D6nQcAuGr66CRH0v2UH0SyS2Q1CHdvMLPrgQVALnCPu68ws2vD9XOB8cB9ZtYIrASuiSqentI8vHdpv8y49yGWbpQTyS6R3ijn7vOB+XHL5sZMLwTGdbCP54DnIgiv2938p+X8qWIT+bk59O+TOfcgWtyriGSHTjUxmdlHzKw4Zr7EzD4cXVjpp7HJ+d0r69lX20BpUUFG/dpuvrIgJ4OOSUQ61tk+iFvcfW/zjLvvAW6JJqT0FPto0cFp/uzpdik/iGSVziaIROUypw2lG+zY35IgBvXNP0rJ9KUKhEh26WyCWGRmd5jZ8WY21sx+AnR4j0I2qY5JEDPGDU5iJN1PeUEkO3W2FvBl4Gbg9+H8k8B3IokoTe0Im5ie/4/zGT2ob5KjERF57zqVINz9ANBmNFZpsfNAPQCDM/DyVhHJTp29iukpMyuJmR9gZguiCyv9rNhcQ0FeDoX5uckOpdvFj48iItmhs01Mg8MrlwBw991mNiSimNLOtppa/rIsGEUkky5vFZHs1tlO6iYzG9U8Y2bl6IflEZv3HEp2CJGaMiqoPPbKyYxhy0Wkczpbg/g28JKZPR/OzwDmRBNS+ml+gtxvZp+Z5Eii8fOrzmBt9X76ZGDzmYi0r7Od1E+Y2VSCpFAB/BnI7J/NXbB9X/D8h4nHFXdQMj31K8hj0oiSjguKSEbpVIIws88TPP5zBEGCmA4sBC6MLrT0sXVvLXk5lrE3yIlIdupso/INwJnAene/AJgCpMbj21LAtpo6hhQVkJOjDmoRyRydTRC17l4LYGYF4fOjT4ourPTxTvV+KrfvY0j/3skORUSkW3W2k7oqvA/iT8BTZrabuKfDZaM3qvbwL3f9AwiePy0ikkk620n9kXDyVjN7FigGnogsqjSxdMORW0MY2l93UItIZunyiKzu/nzHpbLDuh0HjkwfbtJtISKSWXTn0zFyd55ZvZ3yQYUAzBhXmuSIRES6l57pcIxWb93Hhl0H+f7lp/LxM0aQl6tcKyKZRWe1Y7RsY9D/cM4Jg5UcRCQjRXpmM7OZZrbGzCrNrM1w4eGosI+Z2Rtm9pqZTQyXjzSzZ81slZmtMLMboozzWDQPrzFUl7eKSIaKLEGYWS5wNzALmABcaWYT4ordBFS4+yTg08Cd4fIG4GvuPp7gru3rEmybVFtrahncL5/8PNUeRCQzRXl2mwZUuvtad68HHgIuiyszAXgaILz5rtzMhrr7FndfEi7fB6wCyiKMtcu219QypEi1BxHJXFEmiDJgY8x8FW1P8suAywHMbBowmmC8pyPCocWnAK9GFOcx2bTnEMOLlSBEJHNFmSASDUwUf7PAD4ABZlZB8NzrpQTNS8EOzPoBfwS+4u41Cd/EbI6ZLTKzRdXVPTM81OL1u1i9dR/lg/XsaRHJXFFe5loFjIyZH0Hc8BzhSX82gAWPYlsX/mFmvQiSwwPu/mh7b+Lu84B5AFOnTu2Ru9U++vOFAHx4ckq1eomIdKsoaxCvA+PMbIyZ5QNXAI/HFjCzknAdwOeBF9y9JkwWvwZWufsdEcbYZYcbm45MTyzrn8RIRESiFVkNwt0bzOx6YAGQC9zj7ivM7Npw/VxgPHCfmTUCK4Frws3PBq4G3gybnwBucvf5UcXbWQ+9tgGAO6+YrOdPi0hGi/RO6vCEPj9u2dyY6YXAuATbvUTiPoyke3ZNNQV5OXxo0nHJDkVEJFK6iL8LDtQ18Nya7Vw9fbQeDiQiGU8Jogve3r6fJoczxwxMdigiIpFTguiCqt0HARgdjuAqIpLJlCA6ae/Bw1z/P0sBKCvpk+RoRESipwTRSfOXbzkyXdS7VxIjERHpGUoQnfTuzuDpcXdeMTnJkYiI9AwliE5avmkvp5YVc5nunhaRLKEE0QnuzvJNNUwsK052KCIiPUYJohMWvrOTvYcOc6oShIhkESWITnh13S4Azh03OMmRiKSon/0MJkyAPn3ADH7606OX/+xng3Lvvvve3vf884P9RKm7Yk1DkQ61kSnW7zxAWUkfRg7U/Q8ibTz0ENxwA0yZAl/5ChQUwPTpyY4qeuXlsH594nVDh8LWrT0aThSUIDrh3Z0HKR+s5CCS0F//2vJ6XJaNUVZcHCTFeP369XwsEVCC6MCCFVup2LiHiycMTXYoIqlpc/iYl2xLDgAlJXDrrcmOIjLqg+jAj55YDcD0sYOSHIlkhHvvhY9+FMaODdrr+/eHs8+G++9vf5tdu+Db34aJE6GwMPjVetppcOONcODAsZdtT10d/OAHMGlSsI/+/eHcc+EPf2hd7tZbg7b5Z58N5s1a/o7VsXw+zTF/5zswZkzQxHX88fDd70J9feLyq1cHfQsjRwblhw6FT30K1qw59tgzkGoQR7F+5wHeqT7ADReN47NnlSc7HMkE//qvQWfujBkwfDjs3Anz58PVVwcnp9tua11+3Tq44IKgrfuMM4Ltm5rgrbfgJz+Ba6+Fvn27XrY99fVwySXw/PNw8slw3XVw8CA88gh88pNQUQHf+15Q9vzzg9d77w3e85Zbev7zafaJT8Drr8PHPga9esGf/xwksEWL4PHHWyetJ56Ayy+Hw4fhQx+CE06Aqip49FH429+ChHf66Z2Lt64uSF4bNgSf7aRJQey5ue/5o0gJ7p4xf2eccYZ3p1++8I6P/uZffcPOA926X8lilZVtl9XVuV94oXtenntVVet1Z53lDu7f+17b7aqr3Q8dOray7fne94J9zJrlfvhwy/Jt29xHjw7W/eMfrbc577xgeVd85jPBNuvWtV7e1c+n+b3HjXPftatl+aFD7tOnB+vuu69l+a5d7iUl7oMGua9Y0Xpfy5e79+3rPmVK52Jt/jzi/8aMcX/uuY4+gZQBLPJ2zqlqYjqKf1Tu4IQh/XT1knSf449vuyw/P/il3tAATz/dsnzxYnj5ZZg8Gb75zbbbDR4MvXt3vezR3HNP8Gv7jjsgL6aBYcgQuPnmYPpXv+p4P8eqK59PrJtvhgEDWuZ794bvfz+YvueeluX33Qd79gTNTxMmtN7HKafAF74AS5fCypUdxzp7dhDP1q1B892bb8IXvxhcDjtrFixb1vE+UpyamI5i4dqdXHrq8GSHIZlkwwb44Q+DE8uGDXDoUOv1mza1TL/ySvB6ySWQ08Fvua6Ubc++fVBZCWVlQfNSvAsvDF6XLj22/XdGVz6fWOed13bZuecGSS423oULg9dlyxJ3Lr/1VvC6alXbBBIvvklt4kSYOze4gun224P9P/bY0feR4pQg2vH9+auoPdzEJN09Ld1l7VqYNg127w5OXhdfHHQi5+YGvzp/+9ugTbvZnj3Ba1knxv/qStn27N0bvA5v50dR8/Lm9+puXf18Yg1NcJVhbi4MGgTbt7cs27kzeP3lL48ey/79x3QIQNDXc/vt8MILx76PFKEEEcfdeXhxFb94YS1Digr41PtGJzskyRR33BGcoH7zm+AKmlgPPhicAGOVlASv7f1qPtay7SkOfwy1d4PXli2ty3W3rn4+sbZtg1GjWi9rbAz2179/y7Lm2JctCzqUozBkSPDa2avGUlikfRBmNtPM1phZpZndmGD9ADN7zMzeMLPXzGxiZ7eNyjOrt/ONR96gV67xu2veR36eummkm1RWBq8f/Wjbdc8/33ZZ893ICxYEVyMdTVfKtqeoKOgD2LQJ3n677frmy1k7e4VPV3X18+lo/YsvBv0WU6a0LGv+nF588dhi7IzmZqyxY6N7jx4S2dnPzHKBu4FZwATgSjOLb9S7Cahw90nAp4E7u7BtJF6q3EF+bg5v3HIJJw0r6om3lGxRXh68Pvdc6+ULFiTu+D3jDDjrrODS0h/+sO36nTuhtrbrZY/mc58LrsX5j/8IfoE327Gj5RLTz32u4/0ci65+PrFuuy1ommpWWwvf+lYwPXt2y/LZs4Pa1ne/C6+91nY/TU1t3z+RFSuCe07irV8P118fTF91Vcf7SXFRNjFNAyrdfS2AmT0EXAbEXh4wAfg+gLuvNrNyMxsKjO3EtpHYvOcQIwf2oU9+hlzHLKnjS18Kmk8+/vHgV3JZGSxfHlyX/4lPwO9/33ab++8P7je46Sb44x+DaffgF/6TTwY3fDWfWLtStj1f/zr87/8G9xGcdhpcemlwH8TDDwdt+d/4BpxzTnd+Ki2O5fNpNn58cBVS7H0Q77wDH/xgcA9Fs0GDgns6PvKRoDZx0UXBdjk5Qaf4woWdS6YPPxzcTHjBBcHNeUVFwfv97W/BtpdeGnyWaS7KBFEGbIyZrwLeF1dmGXA58JKZTQNGAyM6uW23e27Ndhas2MZlk7NwyACJ3qRJQTPNd74T3PzV0BCchB99NPhVm+gEOGYMLFkCP/oR/OlPcNddwSWc5eXwta+1tHd3tWx78vPhqaeC/oD/+R/47/8OrgQ67bRghNYrr+yuT6OtY/l8mv3hD0Et4oEHgqE/ysqCq4huvLHtnd0XXQRvvAE//nFQO3nxxeC4jzsuuFIrURNXvAsuCG7cW7o0SCoHDgQxnnNOkJCuvjr6UWZ7gAX3SUSwY7OPA5e4++fD+auBae7+5Zgy/QmalaYAbwInA58HTuxo25h9zAHmAIwaNeqM9e2NrtgJn7v3dZ5ZvZ1nvnYeY0szY7AtEZGjMbPF7j410booaxBVwMiY+RHA5tgC7l4DzAYwMwPWhX+FHW0bs495wDyAqVOnvqdst+jdXVw5bZSSg4gI0V7F9DowzszGmFk+cAXweGwBMysJ10FQc3ghTBodbtvd6huaqKltYHhxJ+42FRHJApHVINy9wcyuBxYAucA97r7CzK4N188FxgP3mVkjQQf0NUfbNqpYV26u4YW3qwEY2De/g9IiItkh0hvl3H0+MD9u2dyY6YXAuM5uG5V//0MFq7fuA6BsQJ+eeEsRkZSnu8CAHftbxowfM6iD4ZBFRLKEEgStr0Yr7tMreYGIiKQQJT0H11gAAAo1SURBVIg4/ZUgREQAJYg2cnPS/+YWEZHuoAQhIiIJKUEAqjOIiLSlBCEiIgkpQZARY2qJiHQ7JQgREUlICQIw9UKIiLShBCEiIgkpQaA+CBGRRJQgREQkISUIERFJSAlCREQSUoJAd1KLiCSiBCEiIgkpQQCmy5hERNpQghARkYSUIEREJCElCBERSSjSBGFmM81sjZlVmtmNCdYXm9lfzGyZma0ws9kx674aLltuZg+aWe/o4oxqzyIi6SuyBGFmucDdwCxgAnClmU2IK3YdsNLdTwPOB243s3wzKwP+DZjq7hOBXOCK6GKNas8iIukryhrENKDS3de6ez3wEHBZXBkHiiy4jKgfsAtoCNflAX3MLA8oBDZHGKuIiMSJMkGUARtj5qvCZbHuAsYTnPzfBG5w9yZ33wT8GNgAbAH2uvuTid7EzOaY2SIzW1RdXd3dxyAikrWiTBCJGm48bv4SoAI4DpgM3GVm/c1sAEFtY0y4rq+ZXZXoTdx9nrtPdfeppaWlxxSox0clIiKRJogqYGTM/AjaNhPNBh71QCWwDjgZ+ACwzt2r3f0w8ChwVlSBKkGIiLQVZYJ4HRhnZmPMLJ+gk/nxuDIbgIsAzGwocBKwNlw+3cwKw/6Ji4BVEcYqIiJx8qLasbs3mNn1wAKCq5DucfcVZnZtuH4ucBtwr5m9SdAk9U133wHsMLNHgCUEndZLgXkRxhrVrkVE0lZkCQLA3ecD8+OWzY2Z3gxc3M62twC3RBnfkffqiTcREUkzupMa9UGIiCSiBAG46hAiIm0oQaAahIhIIkoQqA9CRCQRJQharmI6eVhRkiMREUkdShAETUznjhvMI/8a2b14IiJpRwmCoIlp9KBC+hVEetWviEhaUYIgaGKyhENHiYhkLyUIghqEngkhItKaEgRBH4Tyg4hIa0oQhE1MqkKIiLSiBIHugxARSUQJAsDVByEiEk8JgrCTWr0QIiKtKEEQ9EHkKD+IiLSiBAE0qYlJRKQNJQiC4b51FZOISGtKEMDMU4YxfrgG6hMRiaXBh4CfXjEl2SGIiKQc1SBERCShSBOEmc00szVmVmlmNyZYX2xmfzGzZWa2wsxmx6wrMbNHzGy1ma0ys/dHGauIiLQWWYIws1zgbmAWMAG40swmxBW7Dljp7qcB5wO3m1l+uO5O4Al3Pxk4DVgVVawiItJWlDWIaUClu69193rgIeCyuDIOFFlwCVE/YBfQYGb9gRnArwHcvd7d90QYq4iIxIkyQZQBG2Pmq8Jlse4CxgObgTeBG9y9CRgLVAO/MbOlZvYrM+ub6E3MbI6ZLTKzRdXV1d1+ECIi2SrKBJHoxoL4cfEuASqA44DJwF1h7SEPOB34ubtPAQ4AbfowANx9nrtPdfeppaWl3Ra8iEi2izJBVAEjY+ZHENQUYs0GHvVAJbAOODnctsrdXw3LPUKQMEREpIdEmSBeB8aZ2Ziw4/kK4PG4MhuAiwDMbChwErDW3bcCG83spLDcRcDKCGMVEZE45h7d0xDM7FLgp0AucI+7/z8zuxbA3eea2XHAvcBwgiapH7j7/eG2k4FfAfnAWmC2u+/u4P2qgfXHGO5gYMcxbptqMuVYMuU4QMeSqjLlWN7LcYx294Tt85EmiHRiZovcfWqy4+gOmXIsmXIcoGNJVZlyLFEdh+6kFhGRhJQgREQkISWIFvOSHUA3ypRjyZTjAB1LqsqUY4nkONQHISIiCakGISIiCSlBiIhIQlmfIDoakjwVmdm7ZvammVWY2aJw2UAze8rM3g5fB8SU/1Z4fGvM7JLkRQ5mdo+ZbTez5THLuhy7mZ0RfgaVZvYz6+FnxrZzHLea2abwe6kI7wNK6eMIYxhpZs+Gw+qvMLMbwuXp+L20dyxp9d2YWW8ze81aHoXw3XB5z34n7p61fwQ38L1DMDhgPrAMmJDsuDoR97vA4LhlPwJuDKdvBH4YTk8Ij6sAGBMeb24SY59BMGzK8vcSO/Aa8H6CGyz/F5iVAsdxK/D1BGVT9jjCGIYDp4fTRcBbYczp+L20dyxp9d2E79kvnO4FvApM7+nvJNtrEJ0ZkjxdXAb8Npz+LfDhmOUPuXudu68DKgmOOync/QWCYd1jdSl2MxsO9Hf3hR78D7gvZpse0c5xtCdljwPA3be4+5Jweh/Bs1fKSM/vpb1jaU9KHosH9oezvcI/p4e/k2xPEJ0ZkjwVOfCkmS02sznhsqHuvgWC/yTAkHB5OhxjV2MvC6fjl6eC683sjbAJqrn6nzbHYWblwBSCX6xp/b3EHQuk2XdjZrlmVgFsB57yYPDSHv1Osj1BdGZI8lR0trufTvC0vuvMbMZRyqbrMUL7safqMf0cOJ5g6PotwO3h8rQ4DjPrB/wR+Iq71xytaIJlKXU8CY4l7b4bd29098kEI2FPM7OJRykeyXFke4LozJDkKcfdN4ev24HHCJqMtoXVScLX7WHxdDjGrsZeFU7HL08qd98W/qduAn5JS1Neyh+HmfUiOKE+4O6PhovT8ntJdCzp/N148DTN54CZ9PB3ku0JojNDkqcUM+trZkXN08DFwHKCuD8TFvsM8Odw+nHgCjMrMLMxwDiCTqtU0qXYw6r1PjObHl6R8emYbZKm+T9u6CME3wuk+HGE7/1rYJW73xGzKu2+l/aOJd2+GzMrNbOScLoP8AFgNT39nfRUr3yq/gGXElzp8A7w7WTH04l4xxJcrbAMWNEcMzAIeBp4O3wdGLPNt8PjW0MSrpKJi/9Bgir+YYJfN9ccS+zAVIL/5O8QPLrWUuA4fkfw6Nw3wv+ww1P9OMIYziFodniD4AmPFeH/i3T8Xto7lrT6boBJwNIw3uXA/w2X9+h3oqE2REQkoWxvYhIRkXYoQYiISEJKECIikpAShIiIJKQEISIiCSlBiKQAMzvfzP6a7DhEYilBiIhIQkoQIl1gZleF4/RXmNkvwgHV9pvZ7Wa2xMyeNrPSsOxkM3slHCDuseYB4szsBDP7ezjW/xIzOz7cfT8ze8TMVpvZAz35/AGRRJQgRDrJzMYDnyQYLHEy0Aj8H6AvsMSDARSfB24JN7kP+Ka7TyK4i7d5+QPA3e5+GnAWwR3ZEIw8+hWCsf3HAmdHflAiR5GX7ABE0shFwBnA6+GP+z4Eg6U1Ab8Py9wPPGpmxUCJuz8fLv8t8HA4jlaZuz8G4O61AOH+XnP3qnC+AigHXor+sEQSU4IQ6TwDfuvu32q10OzmuHJHG7/maM1GdTHTjej/pySZmphEOu9p4GNmNgSOPB94NMH/o4+FZT4FvOTue4HdZnZuuPxq4HkPnk1QZWYfDvdRYGaFPXoUIp2kXygineTuK83sOwRP88shGMn1OuAAcIqZLQb2EvRTQDAc89wwAawFZofLrwZ+YWb/Ge7j4z14GCKdptFcRd4jM9vv7v2SHYdId1MTk4iIJKQahIiIJKQahIiIJKQEISIiCSlBiIhIQkoQIiKSkBKEiIgk9P8BnwallaF77fQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(axis,acc[4])\n",
    "plt.text(1500, 0.9, 'acc of label5' , fontdict={'size': 20, 'color': 'red'})\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(axis,acc[5])\n",
    "plt.text(1500, 0.5, 'acc of label6' , fontdict={'size': 20, 'color': 'red'})\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-60-6de2221b55f0>:2: MatplotlibDeprecationWarning: Using a string of single character colors as a color sequence is deprecated. Use an explicit list instead.\n",
      "  plt.bar(range(len(name_list)), precisionSet,color='rgb',tick_label=name_list)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "name_list = ['label1','label2','label3','label4','label5','label6']  \n",
    "plt.bar(range(len(name_list)), precisionSet,color='rgb',tick_label=name_list)  \n",
    "plt.xlabel('label')\n",
    "plt.ylabel('precision')\n",
    "plt.show()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-61-098b636d486f>:2: MatplotlibDeprecationWarning: Using a string of single character colors as a color sequence is deprecated. Use an explicit list instead.\n",
      "  plt.bar(range(len(name_list)), recallSet,color='rgb',tick_label=name_list)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "name_list = ['label1','label2','label3','label4','label5','label6']  \n",
    "plt.bar(range(len(name_list)), recallSet,color='rgb',tick_label=name_list)  \n",
    "plt.xlabel('label')\n",
    "plt.ylabel('recall')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-62-0169e5b5e39c>:2: MatplotlibDeprecationWarning: Using a string of single character colors as a color sequence is deprecated. Use an explicit list instead.\n",
      "  plt.bar(range(len(name_list)), f1Set,color='rgb',tick_label=name_list)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEJCAYAAACZjSCSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAARhklEQVR4nO3df5BdZ13H8ffHbYMUlB9mFUxaEiRaigLCGkRFfmjHlJEJSB1SGBGwE4tGEAekjjMgIGiHcXQohZjBUBwZoyO/MhKIDqOA/BizraWQQjo75UeWil3AgSm/SsrXP+5tvb25u0mTfXabfd6vmTs95zxPzv0+c7f3c8+55zw3VYUkqV/ft9oFSJJWl0EgSZ0zCCSpcwaBJHXOIJCkzhkEktS5pkGQZFuSI0nmklw+of1lSa4bPj6V5PYkD2xZkyTprtLqPoIkU8CNwIXAPHAIuKSqblik/9OAl1TVU5oUJEma6KyG+94KzFXVTQBJ9gHbgYlBAFwC/P2Jdrp+/fratGnTctUoSV245pprvlxV05PaWgbBBuDoyPo88LhJHZOcA2wDdp1op5s2bWJ2dnZZCpSkXiT5/GJtLb8jyIRti52Hehrwkar66sQdJTuTzCaZXVhYWLYCJUltg2AeOHdkfSNw8yJ9d7DEaaGq2lNVM1U1Mz098chGknSKWgbBIWBLks1J1jF4s98/3inJ/YAnAu9pWIskaRHNviOoqmNJdgEHgSlgb1UdTnLZsH33sOszgH+pqm+0qkWStLhml4+2MjMzU35ZLEl3T5JrqmpmUpt3FktS5wwCSeqcQSBJnTMIJKlzLe8s1grIqybdt3fPU688sy5KkHriEYEkdc4gkKTOGQSS1DmDQJI6ZxBIUucMAknqnEEgSZ0zCCSpcwaBJHXOIJCkzhkEktQ5g0CSOmcQSFLnDAJJ6pxBIEmdMwgkqXMGgSR1rmkQJNmW5EiSuSSXL9LnSUmuS3I4yQdb1iNJOl6zn6pMMgVcBVwIzAOHkuyvqhtG+twfeBOwraq+kOSHW9UjSZqs5RHBVmCuqm6qqtuAfcD2sT7PBt5ZVV8AqKpbGtYjSZqgZRBsAI6OrM8Pt436ceABSf49yTVJntuwHknSBM1ODQGZsK0mPP9jgV8C7g18LMnHq+rGu+wo2QnsBDjvvPMalCpJ/Wp5RDAPnDuyvhG4eUKf91fVN6rqy8CHgEeN76iq9lTVTFXNTE9PNytYknrUMggOAVuSbE6yDtgB7B/r8x7gCUnOSnIO8Djg0w1rkiSNaXZqqKqOJdkFHASmgL1VdTjJZcP23VX16STvB64Hvge8pao+1aomSdLxWn5HQFUdAA6Mbds9tv564PUt65AkLc47iyWpcwaBJHXOIJCkzhkEktQ5g0CSOmcQSFLnDAJJ6pxBIEmdMwgkqXMGgSR1ziCQpM4ZBJLUOYNAkjpnEEhS5wwCSeqcQSBJnTMIJKlzBoEkdc4gkKTOGQSS1DmDQJI6ZxBIUueaBkGSbUmOJJlLcvmE9icl+VqS64aPV7SsR5J0vLNa7TjJFHAVcCEwDxxKsr+qbhjr+uGq+tVWdUiSltbyiGArMFdVN1XVbcA+YHvD55MknYKWQbABODqyPj/cNu7xST6R5H1JHjFpR0l2JplNMruwsNCiVknqVssgyIRtNbZ+LfCQqnoUcCXw7kk7qqo9VTVTVTPT09PLXKYk9a1lEMwD546sbwRuHu1QVV+vqluHyweAs5Osb1iTJGlMyyA4BGxJsjnJOmAHsH+0Q5IHJclweeuwnq80rEmSNKbZVUNVdSzJLuAgMAXsrarDSS4btu8GLgZemOQY8C1gR1WNnz6SJDXULAjgztM9B8a27R5ZfiPwxpY1SJKW5p3FktQ5g0CSOmcQSFLnDAJJ6pxBIEmdMwgkqXMGgSR1ziCQpM4ZBJLUOYNAkjpnEEhS5wwCSeqcQSBJnTMIJKlzBoEkdc4gkKTOGQSS1DmDQJI61/SnKu9xktWu4OT4s82SVpBHBJLUOYNAkjpnEEhS55oGQZJtSY4kmUty+RL9fibJ7UkublmPJOl4zYIgyRRwFXARcAFwSZILFul3BXCwVS2SpMW1PCLYCsxV1U1VdRuwD9g+od/vAe8AbmlYiyRpES2DYANwdGR9frjtTkk2AM8Adi+1oyQ7k8wmmV1YWFj2QiWpZy2DYNJF++MXyP8V8PKqun2pHVXVnqqaqaqZ6enpZStQktT2hrJ54NyR9Y3AzWN9ZoB9GdzotR54apJjVfXuhnVJkka0DIJDwJYkm4EvAjuAZ492qKrNdywnuRr4Z0NAklZWsyCoqmNJdjG4GmgK2FtVh5NcNmxf8nsBSdLKaDrXUFUdAA6MbZsYAFX1vJa1SJIm885iSeqcQSBJnTMIJKlzBoEkdc4gkKTOGQSS1DmDQJI6d0pBkOS+y12IJGl1nOoRwQ3LWoUkadUsemdxkj9YrAnwiECS1oiljgheBzwA+IGxx31P8O8kSWeQpeYauhZ4d1VdM96Q5NJ2JUmSVtJSn+y/CHw+yYsntM00qkeStMKWCoILgPsAL0jygCQPvOMBfHdlypMktbbUqaG/Bt4PPBS4hrv+9GQNt0uSznCLHhFU1Ruq6uEMflDmoVW1eeRhCEjSGnHCq3+q6oUrUYgkaXV4Gagkdc4gkKTOGQSS1DmDQJI6ZxBIUueaBkGSbUmOJJlLcvmE9u1Jrk9yXZLZJL/Qsh5J0vGWuqHstCSZAq4CLgTmgUNJ9lfV6BTWHwD2V1UleSTwj8D5rWqSJB2v5RHBVmCuqm6qqtuAfcD20Q5VdWtV1XD1PgzuWJYkraCWQbABODqyPj/cdhdJnpHkM8B7gRdM2lGSncNTR7MLCwtNipWkXrUMgkzYdtwn/qp6V1WdDzwdeM2kHVXVnqqaqaqZ6enpZS5TkvrWMgjmgXNH1jcCNy/Wuao+BPxYkvUNa5IkjWkZBIeALUk2J1kH7AD2j3ZI8rAkGS4/BlgHfKVhTZKkMc2uGqqqY0l2AQeBKQazmB5OctmwfTfwTOC5Sb4LfAt41siXx5KkFdAsCACq6gBwYGzb7pHlK4ArWtYgSVqadxZLUucMAknqnEEgSZ0zCCSpcwaBJHXOIJCkzhkEktQ5g0CSOmcQSFLnDAJJ6pxBIEmdMwgkqXMGgSR1ziCQpM4ZBJLUOYNAkjpnEEhS5wwCSeqcQSBJnTMIJKlzBoEkdc4gkKTONQ2CJNuSHEkyl+TyCe3PSXL98PHRJI9qWY8k6XjNgiDJFHAVcBFwAXBJkgvGun0WeGJVPRJ4DbCnVT2SpMlaHhFsBeaq6qaqug3YB2wf7VBVH62q/x2ufhzY2LAeSdIELYNgA3B0ZH1+uG0xvwW8b1JDkp1JZpPMLiwsLGOJkqSWQZAJ22pix+TJDILg5ZPaq2pPVc1U1cz09PQylihJOqvhvueBc0fWNwI3j3dK8kjgLcBFVfWVhvVIkiZoeURwCNiSZHOSdcAOYP9ohyTnAe8EfqOqbmxYiyRpEc2OCKrqWJJdwEFgCthbVYeTXDZs3w28Avgh4E1JAI5V1UyrmiRJx2t5aoiqOgAcGNu2e2T5UuDSljVIkpbmncWS1DmDQJI6ZxBIUucMAknqnEEgSZ0zCCSpcwaBJHXOIJCkzhkEktQ5g0CSOmcQSFLnDAJJ6pxBIEmdMwgkqXMGgSR1ziCQpM4ZBJLUuaa/UCZp7cmrstolnJR6Za12CWcMjwgkqXMGgSR1ziCQpM41DYIk25IcSTKX5PIJ7ecn+ViS7yR5actaJEmTNfuyOMkUcBVwITAPHEqyv6puGOn2VeBFwNNb1SFJWlrLI4KtwFxV3VRVtwH7gO2jHarqlqo6BHy3YR2SpCW0DIINwNGR9fnhNknSPUjLIJh0sfEpXdibZGeS2SSzCwsLp1mWJGlUyyCYB84dWd8I3HwqO6qqPVU1U1Uz09PTy1KcJGmgZRAcArYk2ZxkHbAD2N/w+SRJp6DZVUNVdSzJLuAgMAXsrarDSS4btu9O8iBgFvhB4HtJfh+4oKq+3qouSdJdNZ1rqKoOAAfGtu0eWf4Sg1NGkqRV4qRzUms5MyZpo5ykrVdOMSFJnTMIJKlzBoEkdc4gkKTOGQSS1DmDQJI6ZxBIUucMAknqnEEgSZ0zCCSpcwaBJHXOIJCkzhkEktQ5g0CSOmcQSFLn/D0CSd3r/ScjPCKQpM4ZBJLUOYNAkjpnEEhS5wwCSepc0yBIsi3JkSRzSS6f0J4kbxi2X5/kMS3rkSQdr1kQJJkCrgIuAi4ALklywVi3i4Atw8dO4M2t6pEkTdbyiGArMFdVN1XVbcA+YPtYn+3A39bAx4H7J3lww5okSWNaBsEG4OjI+vxw293tI0lqqOWdxZPu1Ru/L+5k+pBkJ4NTRwC3JjlymrUtp/XAl5d1j6t/m+Oyjyl/sqpjWv7XaPWttb+7tfY3By3GdHpDeshiDS2DYB44d2R9I3DzKfShqvYAe5a7wOWQZLaqZla7juW01sa01sYDa29Ma208cGaNqeWpoUPAliSbk6wDdgD7x/rsB547vHroZ4GvVdV/N6xJkjSm2RFBVR1Lsgs4CEwBe6vqcJLLhu27gQPAU4E54JvA81vVI0marOnso1V1gMGb/ei23SPLBfxuyxpWwD3ylNVpWmtjWmvjgbU3prU2HjiDxpRqNa+pJOmM4BQTktQ5g2Aoya0naN+U5FN3c59XJ7l4uLxrOJVGJVl/OrXejedvPaa3D6cQ+VSSvUnOPp16T+K5W4/nb5J8YjjdyT8lue/p1HuSz990TCPbrjzRcy2HFXiNrk7y2STXDR+PPp16T+K5W48nSV6b5MYkn07yotOp91QZBCvnI8AvA59f7UKW0duB84GfAu4NXLq65Zy2l1TVo6rqkcAXgF2rXdBySDID3H+161hGL6uqRw8f1612MafpeQwuoT+/qh7OYAaGFWcQjEly3yQfSHJtkk8mGZ0W46wkbxv5xHjO8N88NskHk1yT5OCkaTKq6r+q6nMrNY5RDcd0YDg9SAH/yeA+kDN5PF8f9g2DYFuxL9BajSmDOb9eD/zhCg3ljudtMp7V0nA8LwReXVXfA6iqW1ZgOMerKh+DL8xvHf73LOAHh8vrGVzaGmATgzeGnx+27QVeCpwNfBSYHm5/FoNLZQGuBi4ee57PAevX2JjOBq4FnnCmjwd4K/A/wL8B55zprxHwYgZHOnc+1xk+nquBI8D1wF8C9zrDx/MV4I+BWeB9wJbWr9Gkhz9ef7wAr0vyi8D3GMx99CPDtqNV9ZHh8t8BLwLeD/wk8K+DD5JMAfe0m+Jaj+lNwIeq6sMNap+k2Xiq6vnDT9FXMvif962tBjFm2ceU5EeBXwee1Lr4CVq9Rn8EfAlYx+DyzJcDr240hlGtxnMv4NtVNZPk1xgEyROajWIRBsHxngNMA4+tqu8m+Rzw/cO28VMFxeAP5HBVPX7lSrzbmo0pySuH+/7t5Sv3hJq+RlV1e5J/AF7GygVBizH9NPAwYG74ZnROkrmqetiyVj5Zk9eo/n/mge8keSuDT98rodXf3DzwjuHyu1i5v7e78DuC490PuGX4Yj+Zu07UdF6SO17YS4D/YHCYOn3H9iRnJ3nEilZ8Yk3GlORS4FeAS2p4jnOFLPt4MvCwO5aBpwGfaTyOUcs+pqp6b1U9qKo2VdUm4JsrFALQ7m/uwcP/Bng6cLeu2DkNrd4X3g08Zbj8RODGJtWfgEFwvLcDM0lmGXwKGH0z+DTwm0muBx4IvLkGv7VwMXBFkk8A1wE/N77TJC9KMs/gC9Xrk7yl8ThGNRkTsJvB4fHHMriU7xUtBzGixXgCvC3JJ4FPAg9mZU453KHVa7RaWo3n7SOv0XrgTxuO4S7PS5vx/DnwzOGY/oxVuvLOO4slqXMeEUhS5wwCSeqcQSBJnTMIJKlzBoEkdc4gkJaQFZodVFpNBoEkdc4gkE5Cw9knpVVnEEgn59vAM6rqMcCTgb8YTnMA8BPAnhr8jsHXgd/J4Ed6rmQwy+RjGUwm9tpVqFs6ISedk07OWpyVVgIMAulkrcVZaSXAU0PSyVqLs9JKgEEgnay1NjuodCdnH5WkznlEIEmdMwgkqXMGgSR1ziCQpM4ZBJLUOYNAkjpnEEhS5wwCSerc/wHnUL4gKjTq3QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "name_list = ['label1','label2','label3','label4','label5','label6']  \n",
    "plt.bar(range(len(name_list)), f1Set,color='rgb',tick_label=name_list)  \n",
    "plt.xlabel('label')\n",
    "plt.ylabel('f1')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
